#include "asyncexportworker.h"
#include "mergedexportmanager.h"
#include "unifiedpagerenderer.h"
#include "fileidentitymanager.h"
#include "layoutstatemanager.h"
#include "unifiedcachemanager.h"
#include <QDebug>
#include <QApplication>
#include <QDir>
#include <QFileInfo>
#include <QUuid>
#include <QElapsedTimer>
#include <QPdfWriter>
#include <QPageLayout>
#include <QPageSize>
#include <QPainter>
#include <QFile>
#include <QScreen>

AsyncExportWorker::AsyncExportWorker(QObject* parent)
    : QObject(parent)
    , m_exportManager(nullptr)
    , m_pageRenderer(nullptr)
    , m_progressNotifier(new SimpleProgressNotifier(this))
    , m_isProcessing(false)
    , m_isPaused(false)
    , m_isCancelled(false)
    , m_progressTimer(new QTimer(this))
    , m_totalPages(0)
    , m_processedPages(0)
    , m_currentFileIndex(0)
    , m_currentPageIndex(0)
{
    // 设置进度定时器
    m_progressTimer->setInterval(100); // 每100ms更新一次进度
    connect(m_progressTimer, &QTimer::timeout, this, &AsyncExportWorker::onProgressTimer);

}

AsyncExportWorker::~AsyncExportWorker()
{
    cleanup();
}

void AsyncExportWorker::submitTask(const ExportTask& task)
{
    QMutexLocker locker(&m_mutex);

    m_taskQueue.append(task);

    // 如果当前没有处理任务，立即开始处理
    if (!m_isProcessing) {
        QTimer::singleShot(0, this, &AsyncExportWorker::processNextTask);
    }
}

void AsyncExportWorker::cancelCurrentTask()
{
    QMutexLocker locker(&m_mutex);

    m_isCancelled = true;
    m_isPaused = false;

    // 唤醒可能暂停的线程
    wakeFromPause();

    // 更新进度通知器
    m_progressNotifier->setState(SimpleProgressNotifier::Cancelled);

    // 清空任务队列
    m_taskQueue.clear();

    emit taskCancelled(m_currentTask.taskId);
}

void AsyncExportWorker::pauseCurrentTask()
{
    QMutexLocker locker(&m_mutex);

    if (m_isProcessing && !m_isPaused) {
        m_isPaused = true;
        m_progressNotifier->setState(SimpleProgressNotifier::Idle);
    }
}

void AsyncExportWorker::resumeCurrentTask()
{
    QMutexLocker locker(&m_mutex);

    if (m_isProcessing && m_isPaused) {
        m_isPaused = false;
        m_progressNotifier->setState(SimpleProgressNotifier::Processing);
        wakeFromPause();
    }
}

bool AsyncExportWorker::isProcessing() const
{
    QMutexLocker locker(&m_mutex);
    return m_isProcessing;
}

bool AsyncExportWorker::isPaused() const
{
    QMutexLocker locker(&m_mutex);
    return m_isPaused;
}

QString AsyncExportWorker::getCurrentTaskId() const
{
    QMutexLocker locker(&m_mutex);
    return m_currentTask.taskId;
}

void AsyncExportWorker::setExportManager(MergedExportManager* manager)
{
    // 🔧 Martin Fowler重构：移除对MergedExportManager的依赖
    // 新系统直接处理导出，避免线程冲突
    Q_UNUSED(manager);
}

void AsyncExportWorker::setPageRenderer(UnifiedPageRenderer* renderer)
{
    // 🔧 Martin Fowler重构：暂时保留但简化实现
    // 未来版本中可能会完全移除这个依赖
    Q_UNUSED(renderer);
}

void AsyncExportWorker::processNextTask()
{
    QMutexLocker locker(&m_mutex);

    if (m_taskQueue.isEmpty()) {
        m_isProcessing = false;
        m_progressNotifier->reset();
        return;
    }

    // 重置状态
    m_isProcessing = true;
    m_isPaused = false;
    m_isCancelled = false;
    m_processedPages = 0;
    m_currentFileIndex = 0;
    m_currentPageIndex = 0;

    // 获取下一个任务
    m_currentTask = m_taskQueue.takeFirst();

    // 计算总页数
    m_totalPages = 0;
    for (const auto& file : m_currentTask.files) {
        m_totalPages += file.pageCount;
    }


    // 更新进度状态
    m_progressNotifier->setState(SimpleProgressNotifier::Preparing);

    // 启动进度定时器
    m_progressTimer->start();

    // 发出任务开始信号
    emit taskStarted(m_currentTask.taskId);

    // 开始异步处理
    QTimer::singleShot(50, [this]() {
        processTask(m_currentTask);
    });
}

void AsyncExportWorker::processTask(const ExportTask& task)
{

    if (m_isCancelled) {
        return;
    }

    checkPauseCondition();

    try {
        // 🔧 Martin Fowler重构：直接使用主窗口当前显示的页面，确保所见即所得
        // 阶段1：获取主窗口显示的页面 (10-30%)
        m_progressNotifier->setState(SimpleProgressNotifier::Processing);
        m_progressNotifier->setProgress(10);

        if (m_isCancelled) return;
        checkPauseCondition();

        QList<QImage> displayedPages;

        // 直接使用任务中传递的显示页面（从主窗口的PageView获取）
        displayedPages = task.displayedPages;

        if (displayedPages.isEmpty()) {
            qWarning() << "[AsyncExportWorker] 任务中没有显示页面，尝试使用文件处理方式";
            // 回退到文件处理方式
            displayedPages = processFilesToPages(task.files);
        }

        if (displayedPages.isEmpty()) {
            throw std::runtime_error("没有可用的页面进行导出");
        }

        m_progressNotifier->setProgress(30);
        m_processedPages = displayedPages.size();

        if (m_isCancelled) return;
        checkPauseCondition();

        // 阶段2：PDF生成阶段 (30-90%)
        m_progressNotifier->setProgress(30);


        // 使用统一渲染器生成PDF，确保与主窗口显示完全一致
        if (!displayedPages.isEmpty()) {
            try {
                generatePDFWithUnifiedRenderer(displayedPages, task.outputPath, task.settings);

                m_progressNotifier->setProgress(90);
            } catch (const std::exception& e) {
                qCritical() << "[AsyncExportWorker] PDF生成失败:" << e.what();
                emit taskFailed(task.taskId, QString("PDF生成错误: %1").arg(e.what()));
                return;
            }
        }

        // 完成
        m_progressNotifier->setProgress(100);
        m_progressNotifier->setState(SimpleProgressNotifier::Completed);

        emit taskCompleted(task.taskId, task.outputPath);

    } catch (const std::exception& e) {
        qCritical() << "[AsyncExportWorker] Exception during task processing:" << e.what();
        emit taskFailed(task.taskId, QString("Processing error: %1").arg(e.what()));
    }
}

void AsyncExportWorker::loadPagesAsync(const ExportTask& task)
{
    // 注意：这里我们不再预加载所有页面到内存
    // 而是让MergedExportManager自己处理页面加载
    // 这样可以避免内存占用过大和主线程阻塞


    // 模拟页面准备过程
    for (int i = 0; i < task.files.size() && !m_isCancelled; ++i) {
        checkPauseCondition();

        int progress = 10 + (i * 70) / task.files.size();
        m_progressNotifier->setProgress(progress);

        // 让出CPU时间，避免阻塞
        QApplication::processEvents();
        QThread::msleep(50); // 短暂延迟，模拟准备过程
    }
}

void AsyncExportWorker::onExportCompleted(const QString& outputPath)
{
    QMutexLocker locker(&m_mutex);


    m_progressNotifier->setState(SimpleProgressNotifier::Completed);
    m_progressNotifier->setProgress(100);

    emit taskCompleted(m_currentTask.taskId, outputPath);

    // 处理下一个任务
    QTimer::singleShot(1000, this, &AsyncExportWorker::processNextTask);
}

void AsyncExportWorker::onExportFailed(const QString& error)
{
    QMutexLocker locker(&m_mutex);

    qCritical() << "[AsyncExportWorker] Export failed:" << error;

    m_progressNotifier->setState(SimpleProgressNotifier::Failed);

    emit taskFailed(m_currentTask.taskId, error);

    // 处理下一个任务
    QTimer::singleShot(1000, this, &AsyncExportWorker::processNextTask);
}

void AsyncExportWorker::onProgressTimer()
{
    if (m_isProcessing && !m_isPaused && m_totalPages > 0) {
        // 计算当前进度
        int processedInCurrentFile = m_currentPageIndex;
        int previouslyProcessedFiles = m_currentFileIndex;

        int totalProcessed = previouslyProcessedFiles + processedInCurrentFile;
        int progress = 10 + (totalProcessed * 70) / m_totalPages;

        m_progressNotifier->setProgress(progress);
    }
}

void AsyncExportWorker::checkPauseCondition()
{
    while (m_isPaused && !m_isCancelled) {
        m_pauseCondition.wait(&m_mutex);
    }
}

void AsyncExportWorker::wakeFromPause()
{
    m_pauseCondition.wakeAll();
}

QString AsyncExportWorker::generateTaskId() const
{
    return QUuid::createUuid().toString(QUuid::WithoutBraces);
}

QImage AsyncExportWorker::loadPageFromFile(const QString& filePath, int pageIndex)
{
    // 使用统一缓存系统加载页面
    // 这确保了与主系统预览的一致性
    QImage pageImage;

    try {
        // 首先尝试从缓存系统加载页面
        QString fileIdentity = FileIdentityManager::getFileIdentity(filePath);

        // 通过UnifiedCacheManager获取缓存的页面
        // 这里使用与主系统相同的缓存键
        QString cacheKey = QString("%1_page_%2").arg(fileIdentity).arg(pageIndex);

        // 尝试从缓存系统加载
        if (auto* cacheManager = UnifiedCacheManager::instance()) {
            // 从缓存加载页面（使用fileIdentity和pageIndex）
            QImage cachedImage = cacheManager->loadFromCache(fileIdentity, pageIndex);
            if (!cachedImage.isNull()) {
                pageImage = cachedImage;
                return pageImage;
            }
        }

        // 如果缓存中没有，则需要重新处理
        // 这里应该使用与主系统相同的处理逻辑
        qWarning() << "[AsyncExportWorker] 缓存中未找到页面:" << cacheKey << "，尝试重新加载";

        // 简化实现：直接加载原始文件
        // 在完整实现中，这里应该调用ImageProcessor来重新处理文件
        QImage originalImage(filePath);
        if (originalImage.isNull()) {
            qWarning() << "[AsyncExportWorker] 无法加载图片:" << filePath;
            return QImage();
        }

        // 根据pageIndex返回相应的图片部分
        // 这是一个简化的实现，实际中需要根据布局模式来分割
        pageImage = originalImage;


    } catch (const std::exception& e) {
        qCritical() << "[AsyncExportWorker] 加载页面失败:" << e.what();
    }

    return pageImage;
}

void AsyncExportWorker::generatePDFWithUnifiedRenderer(const QList<QImage>& pages, const QString& outputPath, const ProcessingSettings& settings)
{

    if (pages.isEmpty()) {
        throw std::runtime_error("没有页面可以导出");
    }

    // 使用统一渲染器生成PDF，确保与主窗口显示完全一致
    if (!m_pageRenderer) {
        qWarning() << "[AsyncExportWorker] 统一渲染器未设置，使用基本PDF生成";
        generateRealPDF(pages, outputPath, settings);
        return;
    }

    // 配置统一渲染器使用导出设置
    m_pageRenderer->setRenderSettings(settings);

    // 创建PDF写入器
    QPdfWriter writer(outputPath);
    writer.setPageSize(QPageSize::A4);
    writer.setPageOrientation(QPageLayout::Portrait);
    writer.setResolution(settings.standardDPI > 0 ? settings.standardDPI : 300);

    QPainter painter(&writer);
    if (!painter.isActive()) {
        throw std::runtime_error("无法创建PDF绘制器");
    }


    // 使用统一渲染器渲染每一页到PDF
    for (int i = 0; i < pages.size() && !m_isCancelled; ++i) {
        checkPauseCondition();

        const QImage& page = pages[i];
        if (page.isNull()) {
            qWarning() << "[AsyncExportWorker] 跳过空页面:" << i;
            continue;
        }

        // 如果不是第一页，创建新页面
        if (i > 0) {
            writer.newPage();
        }

        // 使用统一渲染器渲染页面到PDF（确保与主窗口显示一致）
        try {
            m_pageRenderer->renderToPDF(&writer, &painter, page, i + 1, pages.size());
        } catch (const std::exception& e) {
            qWarning() << "[AsyncExportWorker] 统一渲染器渲染页面失败:" << e.what();
            // 回退到基本渲染
            QPageLayout pageLayout = writer.pageLayout();
            QRectF pageRect = pageLayout.paintRectPixels(writer.resolution());

            QSizeF imageSize = page.size();
            QSizeF scaledSize = imageSize.scaled(pageRect.size(), Qt::KeepAspectRatio);
            QPointF topLeft(
                (pageRect.width() - scaledSize.width()) / 2,
                (pageRect.height() - scaledSize.height()) / 2
            );
            QRectF targetRect(topLeft, scaledSize);
            painter.drawImage(targetRect, page);
        }

        // 更新进度
        int progress = 30 + (i * 60) / pages.size();
        m_progressNotifier->setProgress(progress);

        QString status = QString("生成PDF页面: %1/%2").arg(i + 1).arg(pages.size());

        // 让出CPU时间
        QApplication::processEvents();
    }

    painter.end();

    if (m_isCancelled) {
        // 如果被取消，删除未完成的PDF文件
        QFile::remove(outputPath);
        throw std::runtime_error("导出被取消");
    }

}

void AsyncExportWorker::generateRealPDF(const QList<QImage>& pages, const QString& outputPath, const ProcessingSettings& settings)
{

    if (pages.isEmpty()) {
        throw std::runtime_error("没有页面可以导出");
    }

    // 使用Qt的PDF功能生成PDF
    QPdfWriter writer(outputPath);
    writer.setPageSize(QPageSize::A4);
    writer.setPageOrientation(QPageLayout::Portrait);
    writer.setResolution(settings.standardDPI > 0 ? settings.standardDPI : 300);

    QPainter painter(&writer);
    if (!painter.isActive()) {
        throw std::runtime_error("无法创建PDF绘制器");
    }

    // 计算页面尺寸和缩放比例
    QPageLayout pageLayout = writer.pageLayout();
    QRectF pageRect = pageLayout.paintRectPixels(writer.resolution());


    for (int i = 0; i < pages.size() && !m_isCancelled; ++i) {
        checkPauseCondition();

        const QImage& page = pages[i];
        if (page.isNull()) {
            qWarning() << "[AsyncExportWorker] 跳过空页面:" << i;
            continue;
        }

        // 如果不是第一页，创建新页面
        if (i > 0) {
            writer.newPage();
        }

        // 计算图片在页面中的位置和缩放
        QSizeF imageSize = page.size();
        QSizeF scaledSize = imageSize.scaled(pageRect.size(), Qt::KeepAspectRatio);

        // 居中绘制
        QPointF topLeft(
            (pageRect.width() - scaledSize.width()) / 2,
            (pageRect.height() - scaledSize.height()) / 2
        );

        QRectF targetRect(topLeft, scaledSize);

        // 绘制页面
        painter.drawImage(targetRect, page);

        // 更新进度
        int progress = 30 + (i * 60) / pages.size();
        m_progressNotifier->setProgress(progress);

        QString status = QString("生成PDF页面: %1/%2").arg(i + 1).arg(pages.size());

        // 让出CPU时间
        QApplication::processEvents();
    }

    painter.end();

    if (m_isCancelled) {
        // 如果被取消，删除未完成的PDF文件
        QFile::remove(outputPath);
        throw std::runtime_error("导出被取消");
    }

}

QList<QImage> AsyncExportWorker::getCurrentDisplayedPages()
{
    // 注意：这个方法现在不使用，因为我们直接从任务中获取displayedPages
    // 保留是为了兼容性
    return QList<QImage>();
}

QList<QImage> AsyncExportWorker::processFilesToPages(const QList<UnifiedFileInfo>& files)
{
    QList<QImage> pages;

    // 这是一个简化的实现，作为回退方案
    for (const auto& file : files) {
        // 直接加载原始文件
        QImage originalImage(file.filePath);
        if (!originalImage.isNull()) {
            pages.append(originalImage);
        }
    }

    return pages;
}

void AsyncExportWorker::cleanup()
{
    QMutexLocker locker(&m_mutex);

    m_progressTimer->stop();
    m_taskQueue.clear();
    m_isProcessing = false;
    m_isPaused = false;
    m_isCancelled = true; // 停止所有处理

    wakeFromPause();
}